{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "de32ead4",
      "metadata": {
        "id": "de32ead4"
      },
      "source": [
        "## Задание 1 (7 баллов)\n",
        "\n",
        "Напишите функцию `func()`, которая будет принимать на вход число и возвращать его последнюю цифру.\n",
        "\n",
        "**Пример ввода:**\n",
        "```python\n",
        "func(242748)\n",
        "```\n",
        "**Пример вывода:**\n",
        "```python   \n",
        "8\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "7d9ad75d",
      "metadata": {
        "id": "7d9ad75d",
        "nbgrader": {
          "grade": false,
          "grade_id": "cell-afe9e37150e0fe59",
          "locked": false,
          "schema_version": 3,
          "solution": true,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "def func(number):\n",
        "    return int(list(str(number))[len(str(number))-1])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "d074651d",
      "metadata": {
        "id": "d074651d",
        "nbgrader": {
          "grade": true,
          "grade_id": "cell-8838fa3f67e686e8",
          "locked": true,
          "points": 7,
          "schema_version": 3,
          "solution": false,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "assert func(192) == 2\n",
        "assert func(242748) == 8\n",
        "assert func(0) == 0\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dbdf79dc",
      "metadata": {
        "id": "dbdf79dc"
      },
      "source": [
        "## Задание 2 (8 баллов)\n",
        "\n",
        "Реализуйте следующую функцию `is_odd()`:\n",
        "\n",
        "Целое число (любое) считывается в переменную `number`.\n",
        "Функция возвращает строку “Четное” (если число является четным) или строку “Нечетное” (если число является нечетным).\n",
        "\n",
        "**Пример ввода:**\n",
        "```python\n",
        "is_odd(456)\n",
        "```\n",
        "\n",
        "**Пример вывода:**\n",
        "```python\n",
        "'Четное'\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5d8d148b",
      "metadata": {
        "id": "5d8d148b",
        "nbgrader": {
          "grade": false,
          "grade_id": "cell-151f8093398cf540",
          "locked": false,
          "schema_version": 3,
          "solution": true,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "def is_odd(number):\n",
        "    if number%2 == 0:\n",
        "        return 'Четное'\n",
        "    return 'Нечетное'\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d855561a",
      "metadata": {
        "id": "d855561a",
        "nbgrader": {
          "grade": true,
          "grade_id": "cell-99dfae8fb930928f",
          "locked": true,
          "points": 8,
          "schema_version": 3,
          "solution": false,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "assert is_odd(19) == 'Нечетное'\n",
        "assert is_odd(456) == 'Четное'\n",
        "assert is_odd(0) == 'Четное'\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2139f9f9",
      "metadata": {
        "id": "2139f9f9"
      },
      "source": [
        "## Задание 3 (8 баллов)\n",
        "\n",
        "Реализуйте следующую функцию `multiple_square()`:\n",
        "\n",
        "* Функция принимает целое положительное число `N1` и целое положительное число `N2`. Гарантируется, что `N2` больше `N1`.\n",
        "* Нужно вернуть список квадратов всех кратных трём чисел от `N1` до `N2` включительно.\n",
        "\n",
        "**Пример ввода:**\n",
        "```python\n",
        "multiple_square(4, 13)\n",
        "```\n",
        "\n",
        "**Пример вывода:**\n",
        "```python\n",
        "[36, 81, 144]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9a01fa5f",
      "metadata": {
        "id": "9a01fa5f",
        "nbgrader": {
          "grade": false,
          "grade_id": "cell-2c1ab714fcad6b0f",
          "locked": false,
          "schema_version": 3,
          "solution": true,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "def multiple_square(N1, N2):\n",
        "    list_result = []\n",
        "    for x in range(N1, N2+1):\n",
        "        if x%3 == 0:\n",
        "            list_result.append(x**2)\n",
        "    return list_result"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "53ecd13b",
      "metadata": {
        "id": "53ecd13b",
        "nbgrader": {
          "grade": true,
          "grade_id": "cell-8929a63445cd70aa",
          "locked": true,
          "points": 8,
          "schema_version": 3,
          "solution": false,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "assert multiple_square(4, 13) == [36, 81, 144]\n",
        "assert multiple_square(18, 22) == [324, 441]\n",
        "assert multiple_square(54, 54) == [2916]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d2f8881b",
      "metadata": {
        "id": "d2f8881b"
      },
      "source": [
        "## Задание 4 (9 баллов)\n",
        "\n",
        "Реализуйте следующую функцию `favorite_sport()`:\n",
        "    \n",
        "* Функция получает два списка одинаковой длины: `names` и `sports`. В первом списке - имена спортсменов, во втором - виды спорта, которыми они занимаются.\n",
        "* Функция возвращает список строк вида “Для `Х` любимый спорт `Y`”, где `Х` - строка из списка `names` под индексом `i`, а `Y`- строка из списка `sports` под индексом `i`.\n",
        "\n",
        "**Пример ввода:**\n",
        "\n",
        "```python\n",
        "favorite_sport(['Иванов', 'Петров', 'Сидоров'],\n",
        "               ['Футбол', 'Баскетбол', 'Плаванье'])\n",
        "```\n",
        "\n",
        "**Пример вывода:**\n",
        "```python\n",
        "['Для Иванов любимый спорт Футбол',\n",
        " 'Для Петров любимый спорт Баскетбол',\n",
        " 'Для Сидоров любимый спорт Плаванье']\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "46fdc2c5",
      "metadata": {
        "id": "46fdc2c5",
        "nbgrader": {
          "grade": false,
          "grade_id": "cell-c6d027c7746510f2",
          "locked": false,
          "schema_version": 3,
          "solution": true,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "def favorite_sport(names, sports):\n",
        "    list_data = []\n",
        "    for index in range(len(names)):\n",
        "        list_data.append(\"Для \" + names[index] + \" любимый спорт \" + sports[index]) \n",
        "    return list_data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0827a850",
      "metadata": {
        "id": "0827a850",
        "nbgrader": {
          "grade": true,
          "grade_id": "cell-a4f847a5c5be7d7f",
          "locked": true,
          "points": 9,
          "schema_version": 3,
          "solution": false,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "assert favorite_sport(['Николаев', 'Смирнова'],\n",
        "                      ['Керлинг', 'Теннис']) == ['Для Николаев любимый спорт Керлинг',\n",
        "                                                 'Для Смирнова любимый спорт Теннис']\n",
        "assert favorite_sport(['Иванов', 'Петров', 'Сидоров'],\n",
        "                      ['Футбол', 'Баскетбол', 'Плаванье']) == ['Для Иванов любимый спорт Футбол',\n",
        "                                                               'Для Петров любимый спорт Баскетбол',\n",
        "                                                               'Для Сидоров любимый спорт Плаванье']\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "20212468",
      "metadata": {
        "id": "20212468"
      },
      "source": [
        "## Задание 5 (8 баллов)\n",
        "\n",
        "Реализуйте следующую функцию `successful_students()`:\n",
        "\n",
        "* Функция принимает две строки, в каждой из них список фамилий студентов (гарантируется, что в каждой строке нет повторяющихся фамилий): в первой строке студенты, _сдавшие_ экзамен по экономике, а во второй строке студенты, _сдавшие_ экзамен по программированию. Списки оформлены через пробел.\n",
        "* Функция возвращает список студентов, сдавших оба экзамена, в виде одной строки, в алфавитном порядке, через точку с запятой.\n",
        "\n",
        "**Пример ввода:**\n",
        "```python\n",
        "successful_students('Иванов Петров Семенов Сидоров Котов', 'Котов Петров Иванов')\n",
        "```\n",
        "    \n",
        "**Пример вывода:**\n",
        "```python\n",
        "'Иванов;Котов;Петров'\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1ff98520",
      "metadata": {
        "id": "1ff98520",
        "nbgrader": {
          "grade": false,
          "grade_id": "cell-2d7909a13279aaaa",
          "locked": false,
          "schema_version": 3,
          "solution": true,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "def successful_students(students1, students2):\n",
        "    return \";\".join(sorted(list(set(students1.split()) & set(students2.split()))))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e2047c18",
      "metadata": {
        "id": "e2047c18",
        "nbgrader": {
          "grade": true,
          "grade_id": "cell-7fcbb026718df2a0",
          "locked": true,
          "points": 8,
          "schema_version": 3,
          "solution": false,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "assert successful_students('Иванов Петров Семенов Сидоров Котов',\n",
        "                           'Котов Петров Иванов') == 'Иванов;Котов;Петров'\n",
        "assert successful_students('Иванов Васильева Петров Смирнова Михайлов Фёдорова Соколов Яковлева',\n",
        "                           'Котов Петров Смирнова') == 'Петров;Смирнова'\n",
        "assert successful_students('Иванов Васильева Яковлева', 'Петров Смирнова Михайлов Фёдорова Соколов') == ''\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "07a4cde3",
      "metadata": {
        "id": "07a4cde3"
      },
      "source": [
        "## Задание 6 (14 баллов)\n",
        "\n",
        "Напишите функцию `calc_mean()`, которая принимает на вход список с числами, и выводит их среднее арифметическое.\n",
        "\n",
        "**Внимание:** использовать дополнительные библиотеки и функцию `sum()` запрещается.\n",
        "\n",
        "**Пример ввода:**\n",
        "```python\n",
        "calc_mean([5, 7, 1, 3])\n",
        "```\n",
        "   \n",
        "**Пример вывода:**\n",
        "```python\n",
        "4.0\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e8e72d4b",
      "metadata": {
        "id": "e8e72d4b",
        "nbgrader": {
          "grade": false,
          "grade_id": "cell-d73256bc1e7f64bb",
          "locked": false,
          "schema_version": 3,
          "solution": true,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "def calc_mean(numbers):\n",
        "    sum1 = 0\n",
        "    for x in numbers:\n",
        "        sum1 += x\n",
        "    if sum1 != 0:\n",
        "        return sum1/len(numbers)\n",
        "    return float(sum1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2ec32eac",
      "metadata": {
        "id": "2ec32eac",
        "nbgrader": {
          "grade": true,
          "grade_id": "cell-24a7ef69d44f76a0",
          "locked": true,
          "points": 14,
          "schema_version": 3,
          "solution": false,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "assert calc_mean([5, 7, 1, 3]) == 4.0\n",
        "assert calc_mean([12, 37, 41]) == 30.0\n",
        "assert calc_mean([6, 5]) == 5.5\n",
        "assert calc_mean([0]) == 0.0\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c25e0ca2",
      "metadata": {
        "id": "c25e0ca2"
      },
      "source": [
        "## Задание 7 (16 баллов)\n",
        "\n",
        "Напишите функцию по заданным условиям:\n",
        "\n",
        "* Функция `summ()` принимает на вход словарь, ключами которого являются категории (продукты, одежда, обучение, лекарства и т.д.), а значениями - списки с потраченными суммами.\n",
        "* Функция должна возвращать категорию, к которой относится наибольшая трата.\n",
        "\n",
        "**Пример ввода:**\n",
        "```python\n",
        "summ({'продукты':[450, 500, 700], 'обучение': [4000, 360], 'одежда' :[7600, 10500]})\n",
        "```\n",
        "**Пример вывода:**\n",
        "```python\n",
        "'одежда'\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bdb44e40",
      "metadata": {
        "id": "bdb44e40",
        "nbgrader": {
          "grade": false,
          "grade_id": "cell-ac315da2459c51ba",
          "locked": false,
          "schema_version": 3,
          "solution": true,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "def summ(shop_dict):\n",
        "    key_max = \"\"\n",
        "    value_sum = 0\n",
        "    for key in shop_dict:\n",
        "        if sum(shop_dict[key]) > value_sum:\n",
        "            value_sum = sum(shop_dict[key])\n",
        "            key_max = key\n",
        "    return key_max"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7420f36f",
      "metadata": {
        "id": "7420f36f",
        "nbgrader": {
          "grade": true,
          "grade_id": "cell-670bd760492601b7",
          "locked": true,
          "points": 16,
          "schema_version": 3,
          "solution": false,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "assert summ({'продукты':[450, 500, 700], 'обучение': [4000, 360], 'одежда' :[7600, 10500]}) == 'одежда'\n",
        "assert summ({'развлечения':[4200, 800], 'транспорт': [28, 28, 28, 360]}) == 'развлечения'\n",
        "assert summ({'medicine':[5600, 8900, 1700], 'insurance': [12500.80, 17000], 'health food' :[6700, 5400.90, 1200]}) == 'insurance'\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9b49f54a",
      "metadata": {
        "id": "9b49f54a"
      },
      "source": [
        "## Задание 8 (16 баллов)\n",
        "\n",
        "Студенты вашего курса пытаются решить задания по программированию. За каждую попытку можно получить от 0 до 100 баллов. Количество попыток неограничено. Каждая попытка записывается строкой в формате “ФАМИЛИЯ N”, где `N` - целое число в интервале от 0 до 100. После этого вводится одна фамилия. Программа должна вывести средний балл попыток для студента с этой фамилией.\n",
        "\n",
        "Реализуйте функцию `avg_try()`, в которую передается список попыток и фамилия студента. Функция возвращает вещественное число - средний балл попыток для указанного студента.\n",
        "\n",
        "**Пример ввода:**\n",
        "```python\n",
        "avg_try(['Котов 86',\n",
        "         'Семенов 23',\n",
        "         'Котов 90',\n",
        "         'Иванов 68',\n",
        "         'Алексеев 50',\n",
        "         'Алексеев 92',\n",
        "         'Котов 90',\n",
        "         'Иванов 73'],\n",
        "        'Алексеев')\n",
        "```\n",
        "**Пример вывода:**\n",
        "```python\n",
        "71.0\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e8e4d1bd",
      "metadata": {
        "id": "e8e4d1bd",
        "nbgrader": {
          "grade": false,
          "grade_id": "cell-36e26f00baafe9f1",
          "locked": false,
          "schema_version": 3,
          "solution": true,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "def avg_try(try_list, student):\n",
        "    average_mark = 0\n",
        "    count = 0\n",
        "    for name_value in try_list:\n",
        "        list_data = name_value.split()\n",
        "        if list_data[0] == student:\n",
        "            average_mark += int(list_data[1])\n",
        "            count+=1\n",
        "    if count!=0:\n",
        "        return average_mark/count\n",
        "    return float(0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "211a0642",
      "metadata": {
        "id": "211a0642",
        "nbgrader": {
          "grade": true,
          "grade_id": "cell-f7062bfd869ef15b",
          "locked": true,
          "points": 16,
          "schema_version": 3,
          "solution": false,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "assert avg_try(['Котов 86',\n",
        "                'Семенов 23',\n",
        "                'Котов 90',\n",
        "                'Иванов 68',\n",
        "                'Алексеев 50',\n",
        "                'Алексеев 92',\n",
        "                'Котов 90',\n",
        "                'Иванов 73'],\n",
        "               'Алексеев') == 71.0\n",
        "assert avg_try(['Котов 86',\n",
        "                'Семенов 23',\n",
        "                'Котов 90',\n",
        "                'Иванов 68',\n",
        "                'Алексеев 50',\n",
        "                'Алексеев 92',\n",
        "                'Котов 90',\n",
        "                'Иванов 73'],\n",
        "               'Иванов') == 70.5\n",
        "assert avg_try(['Котов 86',\n",
        "                'Семенов 23',\n",
        "                'Котов 90',\n",
        "                'Иванов 68',\n",
        "                'Алексеев 50',\n",
        "                'Алексеев 92',\n",
        "                'Котов 90',\n",
        "                'Иванов 73'],\n",
        "               'Котов') == 88.66666666666667\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "65e53b88",
      "metadata": {
        "id": "65e53b88"
      },
      "source": [
        "## Задание 9 (14 баллов)\n",
        "\n",
        "Создайте функцию `cenz()`, которая будет принимать строку и цензурировать (закрывать звездочками) слова длиннее четырех букв.\n",
        "\n",
        "**Примечания:**\n",
        "* не цензурируйте слова, состоящие ровно из четырех букв;\n",
        "* если в строке все слова короткие (четыре буквы и меньше), верните исходную строку;\n",
        "* количество звездочек, замещающих слово, должно быть равным количеству букв в этом слове.\n",
        "\n",
        "**Пример ввода:**\n",
        "```python\n",
        "cenz('хочется уже сдать сессию')\n",
        "```\n",
        "**Пример вывода:**\n",
        "```python\n",
        "'******* уже ***** ******'\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "340fe414",
      "metadata": {
        "id": "340fe414",
        "nbgrader": {
          "grade": false,
          "grade_id": "cell-6b779cdd5ffc6f65",
          "locked": false,
          "schema_version": 3,
          "solution": true,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "def cenz(sentence):\n",
        "    list_data = sentence.split()\n",
        "    list_data_new = sorted(list_data[:], key=len, reverse=True)\n",
        "    if len(list_data_new[0])  <= 4:\n",
        "        return sentence\n",
        "    for index,value in enumerate(list_data):\n",
        "        if len(value) >= 4:\n",
        "            list_data[index] = \"*\" * len(value)\n",
        "    str_new =  \" \".join(list_data)\n",
        "    return str_new"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "45249a6e",
      "metadata": {
        "id": "45249a6e",
        "nbgrader": {
          "grade": true,
          "grade_id": "cell-0cee8d580499dbf9",
          "locked": true,
          "points": 14,
          "schema_version": 3,
          "solution": false,
          "task": false
        }
      },
      "outputs": [],
      "source": [
        "assert cenz('хочется уже сдать сессию') == '******* уже ***** ******'\n",
        "assert cenz('Python - это просто') == '****** - это ******'\n",
        "assert cenz('мама мыла раму') == 'мама мыла раму'\n"
      ]
    }
  ],
  "metadata": {
    "celltoolbar": "Create Assignment",
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}
